﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;  // SQL Server 数据访问核心命名空间
using System.Data;            // 数据操作相关类（DataSet、DataTable等）
using System.Windows.Forms;   // Windows窗体组件（用于MessageBox）
using System.Data.Sql;        // SQL相关类


namespace Sql
{
    /// <summary>
    /// SQL数据库操作类
    /// 提供数据库连接、表创建、数据增删改查等完整功能
    /// 支持本地数据库和远程服务器数据库操作
    /// </summary>
    public class SQL
    {
        // 数据库连接字符串配置
        // public string ConStr = "Data Source=User-2021ITXGRT\\MSSQLSERVER2012;Initial Catalog=master;Integrated Security=True";
        public string ConStr = "Data Source=DESKTOP-G0PV4E2;Initial Catalog=master;Integrated Security=True";   // E300设备连接字符串
        //public string ConStr = "Data Source=DESKTOP-N0DGN5J;Initial Catalog=master;Integrated Security=True";   // HP10H设备连接字符串


        // 远程服务器数据库连接字符串（质量检测系统）
        string ConStrFWQ = "server=100.100.20.21;database = QualityInspection; uid=sa; pwd=#Whfl002536 ";


        // 默认数据库和表名配置
        public string DatabaseStr = "QmlData";                    // 主业务数据库名称
        public string ParameterSetTableStr = "ParameterSetTable_6UV";  // 参数设置表名
        public string TestDataTable = "TestDataTable0330_6UV";    // 测试数据表名

        // 操作员信息数组（从远程数据库读取）
        public string[] OPName;  // 操作员姓名数组
        public string[] OPID;    // 操作员工号数组

        // 连接状态标志和连接对象
        public bool ConState = false;           // 数据库连接状态标识
        public SqlConnection conn = new SqlConnection();  // 可重用的数据库连接对象



        /// <summary>
        /// 创建数据库连接（异步方式）
        /// 注意：此方法存在bug，ConState始终返回false
        /// </summary>
        /// <returns>连接状态（当前实现有问题）</returns>
        public bool Consql()
        {
            SqlConnection conn = new SqlConnection(ConStr);  // 创建新的连接实例
            conn.OpenAsync();  // 异步打开连接

            // BUG：此处应该设置ConState为true，但直接返回了默认值false
            return ConState;  // 始终返回false，需要修复
        }

        /// <summary>
        /// 关闭数据库连接
        /// 安全关闭连接并检查关闭状态
        /// </summary>
        public void Close_SQL()
        {
            try
            {
                conn.Close();  // 关闭数据库连接
                if (conn.State == ConnectionState.Closed)
                {
                    // 连接成功关闭，可在此处添加日志或委托调用
                    //listB_A("数据库断开成功");//调用这个委托
                }
            }
            catch (Exception)
            {
                // 关闭连接时发生异常，静默处理
                // 实际项目中建议记录异常日志
            }
        }

        /// <summary>
        /// 创建新的数据库
        /// </summary>
        /// <param name="tabName">要创建的数据库名称</param>
        /// <returns>创建成功返回true，失败返回false</returns>
        public bool CreateDataBase(string tabName)
        {
            SqlConnection conn = new SqlConnection(ConStr);  // 使用主连接字符串

            // 确保连接处于打开状态
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();  // 同步打开连接
            }

            string sql = "CREATE DATABASE " + tabName;  // 构建创建数据库的SQL语句
            SqlCommand cmd = new SqlCommand(sql, conn);  // 创建SQL命令对象

            try
            {
                cmd.ExecuteNonQuery();  // 执行创建数据库命令
                return true;  // 创建成功
            }
            catch (SqlException)
            {
                // 数据库已存在或其他SQL异常
                return false;  // 创建失败
            }
            finally
            {
                conn.Close();  // 确保连接被关闭，释放资源
            }
        }


       /// <summary>
        /// 创建基础数据表（日期和钢针位置度字段）
        /// 用于存储基本的检测数据
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);  // 创建新连接
            
            // 异步检查并打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 构建SQL语句：切换到指定数据库并创建包含日期和钢针位置度的表
                string content1 = " USE " + db + " CREATE TABLE " + tb + " (日期  Datetime, 钢针位置度-1  varchar(50)) ";
                
                SqlCommand cmd = new SqlCommand(content1, conn);  // 创建命令对象
                cmd.ExecuteNonQuery();  // 执行建表语句
            }
            catch (Exception)
            {
                // 建表失败，静默处理异常
                // 实际项目中应记录错误日志
            }
            finally
            {
                conn.Close();  // 确保连接关闭
            }
        }

        /// <summary>
        /// 创建数据库表-1（报警区间和固定条码配置表）
        /// 用于存储3B、3D、3W型号的上限报警区间和固定条码配置
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable1(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 创建包含6个配置字段的表：3个报警区间 + 3个固定条码
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (上限报警区间3B  varchar(50), 上限报警区间3D varchar(50) ," +
                    " 上限报警区间3W varchar(50) , 固定条码3B varchar(50) ," +
                    " 固定条码3D varchar(50) , 固定条码3W varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 异常静默处理
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建数据库表-2（垫片和密封圈检测结果表）
        /// 用于存储垫片状态、衬环/密封圈状态的检测数据
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable2(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 异步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 创建包含日期、条码、垫片状态、密封圈状态、检测结果的表
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (日期  datetime, 条码 varchar(50) , 垫片状态 varchar(50) ," +
                    " 衬环/密封圈状态 varchar(50), 检测结果 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表

                MessageBox.Show("建表完成", "提示信息");  // 用户提示
            }
            catch (Exception)
            {
                MessageBox.Show("建表失败", "提示信息");  // 错误提示
            }
            finally
            {
                conn.Close();  // 确保连接关闭
            }
        }

        /// <summary>
        /// 创建数据库表-3（13参数配置表）
        /// 用于存储13个通用参数字段的配置表
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable3(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建包含13个参数字段的表结构（参数0-参数12）
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (参数0  varchar(50) ," +
                    " 参数1 varchar(50) ," +
                    " 参数2 varchar(50) ," +
                    " 参数3 varchar(50) ," +
                    " 参数4 varchar(50) ," +
                    " 参数5 varchar(50) ," +
                    " 参数6 varchar(50) ," +
                    " 参数7 varchar(50) ," +
                    " 参数8 varchar(50) ," +
                    " 参数9 varchar(50) ," +
                    " 参数10 varchar(50) ," +
                    " 参数11 varchar(50) ," +
                    " 参数12 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }
        /// <summary>
        /// 创建数据库表-30（16参数配置表）
        /// 用于存储16个通用参数字段的扩展配置表
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable30(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建包含16个参数字段的表结构（参数0-参数15）
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (参数0  varchar(50) ," +
                    " 参数1 varchar(50) ," +
                    " 参数2 varchar(50) ," +
                    " 参数3 varchar(50) ," +
                    " 参数4 varchar(50) ," +
                    " 参数5 varchar(50) ," +
                    " 参数6 varchar(50) ," +
                    " 参数7 varchar(50) ," +
                    " 参数8 varchar(50) ," +
                    " 参数9 varchar(50) ," +
                    " 参数10 varchar(50) ," +
                    " 参数11 varchar(50) ," +
                    " 参数12 varchar(50) ," +
                    " 参数13 varchar(50) ," +
                    " 参数14 varchar(50) ," +
                    " 参数15 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建数据库表-4（日期和条码记录表）
        /// 简化的日期和条码对应关系记录表
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable4(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 创建仅包含日期和条码两个字段的简单表
                string content1 = " USE " + db + " CREATE TABLE  " + tb +
                    "( 日期  datetime, 条码 varchar(50) )";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建数据库表-5（产品配方表）
        /// 用于存储产品配方信息的单列表
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable5(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 创建仅包含产品配方字段的简单表
                string content1 = " USE " + db + " CREATE TABLE  " + tb +
                    "( 产品配方 varchar(50) )";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建数据库表-6（用户登录和标定参数表）
        /// 用于存储用户登录信息和机器标定参数
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable6(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 创建包含登录信息和标定参数的表
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (登录用户  varchar(50) ," +
                    " 登录密码  varchar(50) ," +
                    " 直角标定  varchar(50) ," +
                    " 斜角标定  varchar(50) ," +
                    " PIN针高度补偿 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建数据库表-7（20参数扩展配置表）
        /// 用于存储20个通用参数字段的扩展配置表
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable7(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建包含20个参数字段的表结构（参数0-参数19）
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (参数0  varchar(50) ," +
                    " 参数1  varchar(50) ," +
                    " 参数2  varchar(50) ," +
                    " 参数3  varchar(50) ," +
                    " 参数4  varchar(50) ," +
                    " 参数5  varchar(50) ," +
                    " 参数6  varchar(50) ," +
                    " 参数7  varchar(50) ," +
                    " 参数8  varchar(50) ," +
                    " 参数9  varchar(50) ," +
                    " 参数10  varchar(50) ," +
                    " 参数11  varchar(50) ," +
                    " 参数12  varchar(50) ," +
                    " 参数13  varchar(50) ," +
                    " 参数14  varchar(50) ," +
                    " 参数15  varchar(50) ," +
                    " 参数16  varchar(50) ," +
                    " 参数17  varchar(50) ," +
                    " 参数18  varchar(50) ," +
                    " 参数19 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }




        /// <summary>
        /// 创建数据库表-8（涂胶检测数据表）
        /// 用于存储涂胶面积检测的详细数据，包含多个检测区域
        /// </summary>
        /// <param name="db">目标数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateDataTable8(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建复杂的涂胶检测数据表结构
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (日期  datetime ," +
                    " 条码  varchar(50) ," +
                    " 工位  varchar(50) ," +
                    " [涂胶面积]  varchar(50) ," +
                    " [端子1处像素面积]  varchar(50) ," +
                    " [端子2处像素面积]  varchar(50) ," +
                    " [端子3处像素面积]  varchar(50) ," +
                    " [螺丝1处像素面积]  varchar(50) ," +
                    " [螺丝2处像素面积]  varchar(50) ," +
                    " [端子4处像素面积]  varchar(50) ," +
                    " [螺丝3处像素面积]  varchar(50) ," +
                    " [检测区域1涂胶像素面积]  varchar(50) ," +
                    " [检测区域2涂胶像素面积]  varchar(50) ," +
                    " [检测区域3涂胶像素面积]  varchar(50) ," +
                    " [检测区域4涂胶像素面积]  varchar(50) ," +
                    " [检测区域5涂胶像素面积]  varchar(50) ," +
                    " [检测区域6涂胶像素面积]  varchar(50) ," +
                    " [检测区域7涂胶像素面积]  varchar(50) ," +
                    " [检测区域8涂胶像素面积]  varchar(50) ," +
                    " [检测结果]  varchar(50) ," +
                    " 作业人员 varchar(50) ) ";

                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();  // 执行建表
            }
            catch (Exception)
            {
                // 静默处理异常
            }
            finally
            {
                conn.Close();  // 确保资源释放
            }
        }

        /// <summary>
        /// 创建参数设置表（TCP/IP通信参数配置表）
        /// 用于存储网络通信相关的配置参数
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">要创建的数据表名称</param>
        public void CreateParameterSet(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);

            // 异步检查并打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 构建TCP/IP参数配置表的SQL语句
                // 包含TCPIP地址、端口号和4个通用参数字段
                string content1 = " USE " + db + " CREATE TABLE " + tb +
                    " (TCPIP  varchar(30), 端口号 varchar(30) , " +
                    "参数1 varchar(30), 参数2 varchar(30), " +
                    "参数3 varchar(30) , 参数4 varchar(30)) ";

                SqlCommand cmd = new SqlCommand(content1, conn);  // 创建SQL命令
                cmd.ExecuteNonQuery();  // 执行建表操作
            }
            catch (Exception)
            {
                // 建表失败时静默处理异常
                // 实际项目中建议记录错误日志
            }
            finally
            {
                conn.Close();  // 确保数据库连接被关闭，释放资源
            }
        }


        /// <summary>
        /// 创建断电保持数据表-其他断电保持
        /// 用于存储设备断电后需要保持的状态数据，如车速、转速等参数
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        public void CreateRetainDataTable(string db, string tb)
        {
            // 定义表结构：包含车速、转速、LED状态等字段，使用real数据类型存储浮点数
            string str = "( 车速0 real,车速60 real, 车速120 real,车速180 real ,车速220 real,转速0  real  ,转速2000  real ,转速4000  real,转速6000  real  ,转速8000  real, LEDALLON  real ,LEDALLOFF  real)";
            SqlConnection conn = new SqlConnection(ConStr);
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 构建创建表的SQL语句
                string content1 = " USE " + db + " CREATE TABLE " + tb + str;
                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();
            }
            catch (Exception)
            {
                // 建表失败，静默处理异常
            }
            conn.Close();
        }


        /// <summary>
        /// 创建断电保持数据表-时间计时
        /// 专门用于存储设备运行时间的断电保持数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        public void CreateRetainTime(string db, string tb)
        {
            SqlConnection conn = new SqlConnection(ConStr);
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 创建只包含运行时间字段的表
                string content1 = " USE " + db + " CREATE TABLE " + tb + " (运行时间 real) ";
                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();
            }
            catch (Exception)
            {
                // 建表失败，静默处理异常
            }
            conn.Close();
        }

        /// <summary>
        /// 更新复选框相关数据到数据库
        /// 主要用于更新车速、转速等设备状态参数
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="CountD">包含更新数据的浮点数组</param>
        public void Updata_CheckBox(string db, string tb, float[] CountD)
        {
            // 构建更新字段的字符串，将数组值映射到对应的数据库字段
            string str1 = " 车速0 = " + CountD[0] + ",";
            string str2 = " 车速60 = " + CountD[1] + ",";
            string str3 = " 车速120 = " + CountD[2] + ",";
            string str4 = " 车速180 = " + CountD[3] + ",";
            string str5 = " 车速220 = " + CountD[4] + ",";
            string str6 = " 转速0 = " + CountD[5] + ",";
            string str7 = " 转速2000 = " + CountD[6] + ",";
            string str8 = " 转速4000 = " + CountD[7] + ",";
            string str9 = " 转速6000 = " + CountD[8] + ",";
            string str10 = " 转速8000 = " + CountD[9] + ",";
            string str11 = " LEDALLON = " + CountD[10] + ",";
            string str12 = " LEDALLOFF = " + CountD[11];

            SqlConnection conn = new SqlConnection(ConStr);
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建完整的UPDATE语句
                string content1 = " USE " + db + " UPDATE  " + tb + " set " + str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8 + str9 + str10 + str11 + str12;
                SqlCommand cmd = new SqlCommand(content1, conn);
                cmd.ExecuteNonQuery();
            }
            catch (Exception)
            {
                // 更新失败，静默处理异常
            }
            conn.Close();
        }

        /// <summary>
        /// 检查数据库是否存在
        /// 通过查询系统数据库来验证指定数据库是否存在
        /// </summary>
        /// <param name="databaseName">要检查的数据库名称</param>
        /// <returns>存在返回true，不存在返回false</returns>
        public bool CheckDatabaseExists(string databaseName)
        {
            string sqlCreateDBQuery;
            bool result = false;
            try
            {
                SqlConnection conn = new SqlConnection(ConStr);
                // 查询系统数据库中的数据库列表
                sqlCreateDBQuery = string.Format("SELECT userName from sys.databases WHERE Name  = '{0}'", databaseName);
                using (conn)
                {
                    using (SqlCommand sqlCmd = new SqlCommand(sqlCreateDBQuery, conn))
                    {
                        conn.Open();
                        object resultObj = sqlCmd.ExecuteScalar();
                        int databaseID = 0;

                        if (resultObj != null)
                        {
                            int.TryParse(resultObj.ToString(), out databaseID);
                        }
                        conn.Close();

                        result = (databaseID > 0);
                    }
                }
            }
            catch (Exception)
            {
                result = false;
            }

            return result;
        }

        /// <summary>
        /// 执行数据查询（当前实现不完整）
        /// 该方法目前只建立了查询框架，需要进一步完善查询逻辑
        /// </summary>
        /// <param name="db">数据库名称</param>
        public void DataQuery(string db)
        {
            try
            {
                SqlConnection conn = new SqlConnection(ConStr);
                conn.Open();
                string str = "SELECT userName from db";
                SqlCommand cmd = new SqlCommand(str, conn);
                SqlDataReader sdr = cmd.ExecuteReader();
                sdr.Read();
            }
            catch (Exception)
            {
                // 查询失败，静默处理异常
            }        
        }



        /// <summary>
        /// 插入测试数据到指定表
        /// 用于记录测试过程中的各项参数和结果
        /// </summary>
        /// <param name="str0">日期</param>
        /// <param name="str1">工位</param>
        /// <param name="str2">条码</param>
        /// <param name="str3">泄露值</param>
        /// <param name="str4">最大位移</param>
        /// <param name="str5">最大压力</param>
        /// <param name="str6">检测结果</param>
        public void InsertData(string str0, string str1, string str2, string str3, string str4, string str5, string str6)
        {
            SqlConnection connection_1 = new SqlConnection(ConStr);
            // 构建插入语句，包含日期、工位、条码、测试参数和结果
            string str_1 = " USE  QmlData  insert into  TestDataTable0312  (日期,工位,条码,[泄露值],[最大位移(mm)], [最大压力(N)]  ,[检测结果]) VALUES (' " + str0 + "','" + str1 + "','" + str2 + "','" + str3 + "','" + str4 + "','" + str5 + "','" + str6 + "')";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }

        /// <summary>
        /// 插入条码数据
        /// 专门用于记录产品条码及相关日期信息
        /// </summary>
        /// <param name="str0">日期</param>
        /// <param name="str1">条码</param>
        public void InsertData1(string str0, string str1)
        {
            SqlConnection connection_1 = new SqlConnection(ConStr);
            string str_1 = " USE  QmlData  insert into Barcode (日期,条码) VALUES ('" + str0 + "','" + str1 + "')";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }

        /// <summary>
        /// 插入参数设置数据
        /// 用于保存设备参数配置信息
        /// </summary>
        /// <param name="str0">配方</param>
        /// <param name="str1">参数1</param>
        /// <param name="str2">参数2</param>
        /// <param name="str3">参数3</param>
        /// <param name="str4">参数4</param>
        /// <param name="str5">参数5</param>
        /// <param name="str6">参数6</param>
        /// <param name="str7">参数7</param>
        /// <param name="str8">参数8</param>
        /// <param name="str9">参数9</param>
        /// <param name="str10">参数10</param>
        /// <param name="str11">参数11</param>
        public void InsertData3(string str0, string str1, string str2, string str3, string str4, string str5, string str6, string str7, string str8, string str9, string str10, string str11)
        {
            SqlConnection connection_1 = new SqlConnection(ConStr);
            string str_1 = " USE  QmlData  insert into ParameterSetTable (配方,参数1,参数2,参数3,参数4, 参数5  ,参数6, 参数7 ,参数8,参数9,参数10,参数11) VALUES ('" + str0 + "','" + str1 + "','" + str2 + "','" + str3 + "','" + str4 + "','" + str5 + "','" + str6 + "','" + str7 + "','" + str8 + "','" + str9 + "','" + str10 + "','" + str11 + "')";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }

        /// <summary>
        /// 使用数组插入测试数据
        /// 动态构建插入语句，支持可变数量的参数
        /// </summary>
        /// <param name="str">包含所有字段值的字符串数组</param>
        public void InsertData31(string[] str)
        {
            string Str1 = "";
            // 构建VALUES部分的参数字符串
            for (int i = 0; i < str.Length; i++)
            {
                Str1 = Str1 + "'" + str[i] + "'" + ",";
            }
            Str1 = Str1.TrimEnd(',');
            Str1 = Str1.TrimEnd(',');

            SqlConnection connection_1 = new SqlConnection(ConStr);
            // 使用动态构建的VALUES部分
            string str_1 = " USE  QmlData  insert into " + TestDataTable + " VALUES (" + Str1 + ")";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }

        /// <summary>
        /// 插入质量检测数据到远程服务器
        /// 用于将检测数据同步到远程质量检测数据库
        /// </summary>
        /// <param name="str">包含26个检测参数的字符串数组</param>
        public void InsertData32(string[] str)
        {
            string Str1 = "";
            // 构建26个参数的VALUES部分
            for (int i = 0; i < 26; i++)
            {
                Str1 = Str1 + "'" + str[i] + "'" + ",";
            }
            Str1 = Str1.TrimEnd(',');
            Str1 = Str1.TrimEnd(',');

            SqlConnection connection_1 = new SqlConnection(ConStrFWQ);
            // 插入到远程服务器的质量检测表，包含电压、电流、功率、转速等详细参数
            string str_1 = " USE  QualityInspection  insert into [14#controller detectionOP30-1] (日期,工位,条码,[段1电压(V)],[段1电流(A)], [段1功率(W)]  ,[段1实际转速(%)(LIN)], [段1低电平时间(S)(PWM)] ,[段2电压(V)],[段2电流(A)],[段2功率(W)],[段2实际转速(%)(LIN)],[段2低电平时间(S)(PWM)],[段3电压(V)],[段3电流(A)],[段3功率(W)],[段3实际转速(%)(LIN)],[段3低电平时间(S)(PWM)],空转反馈,堵转反馈,过流反馈,欠压反馈,过压反馈,检测信息,判定结果,作业人员) VALUES (" + Str1 + ")";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }

        /// <summary>
        /// 插入PIN针高度测试数据
        /// 用于记录PIN针的高度差、间隔和角度等测量数据
        /// </summary>
        /// <param name="str0">日期</param>
        /// <param name="str1">条码</param>
        /// <param name="str2">PIN1高度差</param>
        /// <param name="str3">PIN2高度差</param>
        /// <param name="str4">PIN3高度差</param>
        /// <param name="str5">PIN1与PIN2间隔</param>
        /// <param name="str6">PIN2与PIN3间隔</param>
        /// <param name="str7">PIN1与PIN2角度</param>
        /// <param name="str8">PIN1与PIN3角度</param>
        /// <param name="str9">PIN2与PIN3角度</param>
        /// <param name="str10">产品状态</param>
        public void InsertData4(string str0, string str1, string str2, string str3, string str4, string str5, string str6, string str7, string str8, string str9, string str10)
        {
            SqlConnection connection_1 = new SqlConnection(ConStr);
            string str_1 = " USE  QmlData  insert into TestDataTable (日期,条码,PIN1高度差,PIN2高度差,PIN3高度差, PIN1与PIN2间隔  ,PIN2与PIN3间隔,PIN1与PIN2角度,PIN1与PIN3角度,PIN2与PIN3角度 ,产品状态) VALUES" +
                " (' " + str0 + "','" + str1 + "','" + str2 + "','" + str3 + "','" + str4 + "','" + str5 + "','" + str6 + "','" + str7 + "','" + str8 + "','" + str9 + "','" + str10 + "' )";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                MessageBox.Show("保存失败", "提示信息", MessageBoxButtons.OKCancel);
            }
            connection_1.Close();
        }

        /// <summary>
        /// 插入参数设置数据（数组版本）
        /// 使用字符串数组插入多参数配置
        /// </summary>
        /// <param name="str">包含13个参数的字符串数组</param>
        public void InsertData5(string[] str)
        {
            SqlConnection connection_1 = new SqlConnection(ConStr);
            string str_1 = " USE  QmlData  insert into ParameterSetTable1 (参数0,参数1,参数2,参数3,参数4, 参数5  ,参数6, 参数7 ,参数8,参数9,参数10,参数11,参数12) VALUES ('" + str[0] + "','" + str[1] + "','" + str[2] + "','" + str[3] + "','" + str[4] + "','" + str[5] + "','" + str[6] + "','" + str[7] + "','" + str[8] + "','" + str[9] + "','" + str[10] + "','" + str[11] + "','" + str[12] + "')";
            try
            {
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }
            connection_1.Close();
        }



        /// <summary>
        /// 插入数据到参数表（动态列版本）
        /// 根据参数数量动态构建插入语句，支持任意数量的参数列
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="str">参数值数组</param>
        /// <param name="Num">参数数量</param>
        public void InsertData51(string db, string tb, string[] str, int Num)
        {
            // 创建数据库连接对象
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 动态构建列名字符串（参数0,参数1,参数2...）
            string Str参数 = "";
            // 动态构建VALUES部分的参数字符串（'值1','值2','值3'...）
            string StrValue = "";

            // 循环构建列名和VALUES部分
            for (int i = 0; i < Num; i++)
            {
                Str参数 = Str参数 + "参数" + i.ToString() + ",";  // 构建列名：参数0,参数1,参数2...
            }
            for (int i = 0; i < Num; i++)
            {
                StrValue = StrValue + "'" + str[i] + "'" + ",";   // 构建VALUES值：'值1','值2','值3'...
            }

            // 去除末尾多余的逗号
            Str参数 = Str参数.TrimEnd(',');
            StrValue = StrValue.TrimEnd(',');

            // 构建完整的INSERT SQL语句
            string str_1 = " USE " + db + " insert into  " + tb + " ( " + Str参数 + ") VALUES  (" + StrValue + " )";

            try
            {
                // 检查连接状态，如果未打开则打开连接
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行插入操作
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
                // 实际项目中建议记录错误日志
            }

            // 确保连接关闭，释放资源
            connection_1.Close();
        }

        /// <summary>
        /// 插入数据到固定列参数表（13参数版本）
        /// 向包含13个固定参数列的表插入数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="str">包含13个参数值的字符串数组</param>
        public void InsertData6(string db, string tb, string[] str)
        {
            // 创建数据库连接
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 构建固定13参数的INSERT SQL语句
            string str_1 = " USE " + db + " insert into  " + tb + " (参数0,参数1,参数2,参数3,参数4, 参数5  ,参数6, 参数7 ,参数8,参数9,参数10,参数11,参数12) VALUES ('" + str[0] + "','" + str[1] + "','" + str[2] + "','" + str[3] + "','" + str[4] + "','" + str[5] + "','" + str[6] + "','" + str[7] + "','" + str[8] + "','" + str[9] + "','" + str[10] + "','" + str[11] + "','" + str[12] + "')";

            try
            {
                // 检查并打开数据库连接
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行插入操作
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }

            // 确保连接关闭
            connection_1.Close();
        }

        /// <summary>
        /// 插入垫片和密封圈检测数据
        /// 向垫片检测表插入日期、条码、垫片状态、密封圈状态和检测结果
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="str0">日期</param>
        /// <param name="str1">条码</param>
        /// <param name="str2">垫片状态</param>
        /// <param name="str3">衬环/密封圈状态</param>
        /// <param name="str4">检测结果</param>
        public void InsertData60(string db, string tb, string str0, string str1, string str2, string str3, string str4)
        {
            // 创建数据库连接
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 构建垫片检测数据的INSERT SQL语句
            string str_1 = " USE " + db + " insert into  " + tb + " (日期,条码,垫片状态,[衬环/密封圈状态], 检测结果) VALUES ('" + str0 + "','" + str1 + "','" + str2 + "','" + str3 + "','" + str4 + "')";

            try
            {
                // 检查并打开数据库连接
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行插入操作
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
            }

            // 确保连接关闭
            connection_1.Close();
        }

        /// <summary>
        /// 读取数据库单行单列浮点数据
        /// 读取指定表最新10条记录中的第一行第一列数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="num">参数索引（当前方法未使用）</param>
        /// <returns>读取的浮点数值，失败返回0</returns>
        public float ReadDtata1(string db, string tb, int num)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 异步检查并打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.OpenAsync();
            }

            try
            {
                // 构建查询语句：获取最新10条记录，按日期降序排列
                string content1 = "USE  QmlData  SELECT TOP 10 *   FROM  " + tb + " order by  [日期] desc ";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 获取行数（当前未使用）
                int row = dataSet_1.Tables[0].Rows.Count;

                // 读取第一行第一列数据并转换为浮点数
                float ABC = float.Parse(dataSet_1.Tables[0].Rows[0][0].ToString().Trim());

                // 关闭连接并返回结果
                conn.Close();
                return ABC;
            }
            catch (Exception)
            {
                // 读取失败返回0
                return 0;
            }
        }

        /// <summary>
        /// 读取数据库多行多列字符串数据
        /// 读取指定表最新10条记录的所有列数据到字符串数组
        /// 注意：此方法存在数组越界风险，row可能大于ABC数组长度
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="num">参数索引（当前方法未使用）</param>
        /// <returns>字符串数组，包含所有列的数据</returns>
        public string[] ReadDtata3(string db, string tb, int num)
        {
            string[] ABC = null;  // 初始化返回数组
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建查询语句：获取最新10条记录
            string content1 = "USE  QmlData  SELECT TOP 10 *   FROM  " + tb + " order by  [日期] desc ";
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 使用DataAdapter填充DataSet
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
            sqlDataAdapter_1.SelectCommand = cmd;
            DataSet dataSet_1 = new DataSet();
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取记录行数
            int row = dataSet_1.Tables[0].Rows.Count;

            // BUG：数组未初始化且循环条件可能越界
            for (int i = 0; i <= row; i++)  // 应该为 i < row，且ABC需要初始化
            {
                ABC[i] = dataSet_1.Tables[0].Rows[0][i].ToString();  // 始终读取第一行的数据
            }

            // 关闭连接并返回结果
            conn.Close();
            return ABC;
        }

        /// <summary>
        /// 读取数据库单列所有数据（第0列）
        /// 读取指定表所有记录的第一列数据到字符串数组
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含第一列所有数据的字符串数组</returns>
        public string[] ReadDtata2(string db, string tb)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建查询所有记录的SQL语句
            string content1 = "USE  QmlData  SELECT  *   FROM  " + tb;
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 使用DataAdapter填充DataSet
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
            sqlDataAdapter_1.SelectCommand = cmd;
            DataSet dataSet_1 = new DataSet();
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取记录行数
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建返回数组并填充第一列数据
            string[] ABC = new string[row];
            for (int i = 0; i < row; i++)
            {
                ABC[i] = dataSet_1.Tables[0].Rows[i][0].ToString();  // 读取每行第一列数据
            }

            // 关闭连接并返回结果
            conn.Close();
            return ABC;
        }

        /// <summary>
        /// 读取数据库单列所有数据（第1列）
        /// 读取指定表所有记录的第二列数据到字符串数组
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含第二列所有数据的字符串数组</returns>
        public string[] ReadDtata2_2(string db, string tb)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建查询所有记录的SQL语句
            string content1 = "USE  QmlData  SELECT  *   FROM  " + tb;
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 使用DataAdapter填充DataSet
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
            sqlDataAdapter_1.SelectCommand = cmd;
            DataSet dataSet_1 = new DataSet();
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取记录行数
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建返回数组并填充第二列数据
            string[] ABC = new string[row];
            for (int i = 0; i < row; i++)
            {
                ABC[i] = dataSet_1.Tables[0].Rows[i][1].ToString();  // 读取每行第二列数据
            }

            // 关闭连接并返回结果
            conn.Close();
            return ABC;
        }



        /// <summary>
        /// 读取数据库单行所有列数据
        /// 读取指定表指定行的所有列数据到字符串数组
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="index">要读取的行索引</param>
        /// <returns>包含指定行所有列数据的字符串数组</returns>
        public string[] ReadDtata21(string db, string tb, int index)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建查询所有记录的SQL语句
            string content1 = "USE " + db + " SELECT  *   FROM  " + tb;
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 使用DataAdapter填充DataSet
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
            sqlDataAdapter_1.SelectCommand = cmd;
            DataSet dataSet_1 = new DataSet();
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取列数
            int Column = dataSet_1.Tables[0].Columns.Count;

            // 创建返回数组并填充指定行的所有列数据
            string[] ABC = new string[Column];
            for (int i = 0; i < Column; i++)
            {
                ABC[i] = dataSet_1.Tables[0].Rows[index][i].ToString();  // 读取指定行的所有列数据
            }

            // 关闭连接并返回结果
            conn.Close();
            return ABC;
        }

        /// <summary>
        /// 统计时间段内的总产量
        /// 统计指定时间段内所有工位的总产量（记录数）
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="EndTime">结束时间</param>
        /// <returns>时间段内的总记录数</returns>
        public int ReadDtata4(string db, string tb, DateTime StartTime, DateTime EndTime)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建按时间范围查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + " '";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 获取记录行数即为产量
                int row = dataSet_1.Tables[0].Rows.Count;

                // 关闭连接并返回结果
                conn.Close();
                return row;
            }
            catch (Exception)
            {
                // 查询失败返回0，确保连接关闭
                conn.Close();
                return 0;
            }
        }

        /// <summary>
        /// 统计右工位时间段内的产量
        /// 统计指定时间段内右工位的产量（记录数）
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="EndTime">结束时间</param>
        /// <returns>右工位在时间段内的记录数</returns>
        public int ReadDtata5(string db, string tb, DateTime StartTime, DateTime EndTime)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建按时间范围和工位条件查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + " ' and  工位='右工位'";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 获取记录行数即为右工位产量
                int row = dataSet_1.Tables[0].Rows.Count;

                // 关闭连接并返回结果
                conn.Close();
                return row;
            }
            catch (Exception)
            {
                // 查询失败返回0，确保连接关闭
                conn.Close();
                return 0;
            }
        }

        /// <summary>
        /// 统计时间段内的合格品数量
        /// 统计指定时间段内检测结果为OK的合格品数量
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="EndTime">结束时间</param>
        /// <returns>时间段内的合格品数量</returns>
        public int ReadDtata6(string db, string tb, DateTime StartTime, DateTime EndTime)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建按时间范围和检测结果条件查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + " '  and  检测结果='OK' ";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 获取记录行数即为合格品数量
                int row = dataSet_1.Tables[0].Rows.Count;

                // 关闭连接并返回结果
                conn.Close();
                return row;
            }
            catch (Exception)
            {
                // 查询失败返回0，确保连接关闭
                conn.Close();
                return 0;
            }
        }

        /// <summary>
        /// 统计右工位时间段内的合格品数量
        /// 统计指定时间段内右工位且判定结果为OK的合格品数量
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="EndTime">结束时间</param>
        /// <returns>右工位在时间段内的合格品数量</returns>
        public int ReadDtata7(string db, string tb, DateTime StartTime, DateTime EndTime)
        {
            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            try
            {
                // 构建按时间范围、工位和判定结果条件查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + " ' and  工位='右工位' and  判定结果='OK' ";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 获取记录行数即为右工位合格品数量
                int row = dataSet_1.Tables[0].Rows.Count;

                // 关闭连接并返回结果
                conn.Close();
                return row;
            }
            catch (Exception)
            {
                // 查询失败返回0，确保连接关闭
                conn.Close();
                return 0;
            }
        }

        /// <summary>
        /// 统计月内每日产量数据
        /// 获取指定年份月份中每一天的产量数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Year0">年份</param>
        /// <param name="Month0">月份</param>
        /// <returns>包含当月每日产量的整型数组</returns>
        public int[] ReadDtata17(string db, string tb, int Year0, int Month0)
        {
            // 获取指定月份的天数
            int Num = DateTime.DaysInMonth(Year0, Month0);
            // 创建存储每日产量的数组
            int[] DataNum = new int[Num];

            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 循环统计每一天的产量
            for (int i = 1; i <= Num; i++)
            {
                // 设置当天的开始时间（00:00:00）和结束时间（23:59:59）
                DateTime StartTime = new DateTime(Year0, Month0, i, 0, 0, 0);
                DateTime EndTime = new DateTime(Year0, Month0, i, 23, 59, 59);

                // 构建按当天时间范围查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + "'";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 记录当天的产量（记录数）
                DataNum[i - 1] = dataSet_1.Tables[0].Rows.Count;
            }

            // 返回当月每日产量数组
            return DataNum;
        }

        /// <summary>
        /// 统计年内每月产量数据
        /// 获取指定年份中每个月的产量数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Year0">年份</param>
        /// <returns>包含当年每月产量的整型数组（12个月）</returns>
        public int[] ReadDtata18(string db, string tb, int Year0)
        {
            // 创建存储12个月产量的数组
            int[] DataNum = new int[12];

            // 创建数据库连接
            SqlConnection conn = new SqlConnection(ConStr);

            // 同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 循环统计每个月的产量
            for (int i = 1; i <= 12; i++)
            {
                // 获取当月的天数
                int Num = DateTime.DaysInMonth(Year0, i);
                // 设置当月的开始时间（第一天00:00:00）和结束时间（最后一天23:59:59）
                DateTime StartTime = new DateTime(Year0, i, 1, 0, 0, 0);
                DateTime EndTime = new DateTime(Year0, i, Num, 23, 59, 59);

                // 构建按月时间范围查询的SQL语句
                string content1 = "USE  QmlData  SELECT  *   FROM  " + tb + " where [日期] BETWEEN  '" + StartTime + "' and  '" + EndTime + "'";
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 使用DataAdapter填充DataSet
                SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);
                sqlDataAdapter_1.SelectCommand = cmd;
                DataSet dataSet_1 = new DataSet();
                sqlDataAdapter_1.Fill(dataSet_1, tb);

                // 记录当月的产量（记录数）
                DataNum[i - 1] = dataSet_1.Tables[0].Rows.Count;
            }

            // 返回当年每月产量数组
            return DataNum;
        }




        /// <summary>
        /// 读取数据库数据 - 读取参数配置
        /// 从指定数据库表中读取第一行所有列的参数配置数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含所有列数据的字符串数组</returns>
        public string[] ReadDtata8(string db, string tb)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：使用指定数据库并查询表中所有数据
            string content1 = "USE  QmlData  SELECT  *   FROM  " + tb;

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集，并将结果存储在指定表名中
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的列数
            int Column = dataSet_1.Tables[0].Columns.Count;

            // 创建返回数组，大小等于列数
            string[] Array1 = new string[Column];

            // 遍历所有列，读取第一行每列的数据
            for (int i = 0; i < Column; i++)
            {
                // 将第一行第i列的数据转换为字符串并存储到返回数组中
                Array1[i] = dataSet_1.Tables[0].Rows[0][i].ToString();
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含所有列数据的数组
            return Array1;
        }

        /// <summary>
        /// 读取远程数据库数据 - 操作员信息
        /// 从远程服务器的质量检测数据库读取操作员姓名和工号信息
        /// </summary>
        /// <param name="tb">数据表名称</param>
        public void ReadDtata32(string tb)
        {
            // 创建远程数据库连接对象
            SqlConnection conn = new SqlConnection(ConStrFWQ);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：使用质量检测数据库并查询指定表的所有数据
            string content1 = "USE  QualityInspection  SELECT  *   FROM  " + tb;

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStrFWQ, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的行数（操作员数量）
            int row = dataSet_1.Tables[0].Rows.Count;

            // 初始化操作员姓名数组，大小为行数
            OPName = new string[row];

            // 初始化操作员工号数组，大小为行数
            OPID = new string[row];

            // 遍历所有行，读取操作员信息
            for (int i = 0; i < row; i++)
            {
                // 读取第2列（索引2）的操作员姓名
                OPName[i] = dataSet_1.Tables[0].Rows[i][2].ToString();

                // 读取第4列（索引4）的操作员工号
                OPID[i] = dataSet_1.Tables[0].Rows[i][4].ToString();
            }

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 读取远程数据库数据 - 操作员工号
        /// 从远程服务器的质量检测数据库读取所有操作员的工号信息
        /// </summary>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含所有操作员工号的字符串数组</returns>
        public string[] ReadDtata33(string tb)
        {
            // 创建远程数据库连接对象
            SqlConnection conn = new SqlConnection(ConStrFWQ);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：使用质量检测数据库并查询指定表的所有数据
            string content1 = "USE  QualityInspection  SELECT  *   FROM  " + tb;

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStrFWQ, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的行数（操作员数量）
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建返回数组，大小为行数
            string[] ABC = new string[row];

            // 遍历所有行，读取操作员工号
            for (int i = 0; i < row; i++)
            {
                // 读取第4列（索引4）的操作员工号并存储到返回数组中
                ABC[i] = dataSet_1.Tables[0].Rows[i][4].ToString();
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含所有操作员工号的数组
            return ABC;
        }

        /// <summary>
        /// 读取数据库数据 - 左工位泄露量历史数据
        /// 读取左工位最新的10条泄露量测量数据，按日期降序排列
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含10个泄露量值的浮点数数组</returns>
        public float[] ReadDtata9(string db, string tb)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：查询左工位最新的10条泄露量数据，按日期降序排列
            string content1 = "USE  QmlData  SELECT  top 10 泄露量1   FROM  " + tb + " where 工位='左工位' order by  [日期] desc ";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的行数（实际返回的记录数）
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建临时字符串数组存储原始数据
            string[] Array1 = new string[row];

            // 创建返回的浮点数数组
            float[] Array2 = new float[row];

            // 遍历所有行，处理数据
            for (int i = 0; i < row; i++)
            {
                // 读取第0列（泄露量）的字符串值
                Array1[i] = dataSet_1.Tables[0].Rows[i][0].ToString();

                // 将字符串转换为浮点数
                Array2[i] = float.Parse(Array1[i]);
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含泄露量值的浮点数数组
            return Array2;
        }

        /// <summary>
        /// 读取数据库数据 - 右工位泄露量历史数据
        /// 读取右工位最新的10条泄露量测量数据，按日期降序排列
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含10个泄露量值的浮点数数组</returns>
        public float[] ReadDtata10(string db, string tb)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：查询右工位最新的10条泄露量数据，按日期降序排列
            string content1 = "USE  QmlData  SELECT  top 10 泄露量1   FROM  " + tb + " where 工位='右工位' order by  [日期] desc ";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的行数（实际返回的记录数）
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建临时字符串数组存储原始数据
            string[] Array1 = new string[row];

            // 创建返回的浮点数数组
            float[] Array2 = new float[row];

            // 遍历所有行，处理数据
            for (int i = 0; i < row; i++)
            {
                // 读取第0列（泄露量）的字符串值
                Array1[i] = dataSet_1.Tables[0].Rows[i][0].ToString();

                // 将字符串转换为浮点数
                Array2[i] = float.Parse(Array1[i]);
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含泄露量值的浮点数数组
            return Array2;
        }

        /// <summary>
        /// 读取数据库数据 - 条码历史记录
        /// 读取最新的1000条产品条码记录，按日期降序排列
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <returns>包含1000个条码的字符串数组</returns>
        public string[] ReadDtata11(string db, string tb)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：查询最新的1000条条码记录，按日期降序排列
            string content1 = "USE  QmlData  SELECT  top 1000 条码   FROM  " + tb + " order by  [日期] desc ";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的行数（实际返回的记录数，最多1000条）
            int row = dataSet_1.Tables[0].Rows.Count;

            // 创建返回的字符串数组
            string[] Array1 = new string[row];

            // 创建临时浮点数数组（当前方法未使用）
            float[] Array2 = new float[row];

            // 遍历所有行，读取条码数据
            for (int i = 0; i < row; i++)
            {
                // 读取第0列（条码）的字符串值
                Array1[i] = dataSet_1.Tables[0].Rows[i][0].ToString();
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含条码的字符串数组
            return Array1;
        }





        /// <summary>
        /// 读取数据库数据 - 指定行的参数数据
        /// 从指定数据库表中读取特定行的所有列数据
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="idex">要读取的行索引</param>
        /// <returns>包含指定行所有列数据的字符串数组</returns>
        public string[] ReadDtata13(string db, string tb, int idex)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建SQL查询语句：使用指定数据库并查询表中所有数据
            string content1 = "USE  " + db + " SELECT  *   FROM  " + tb;

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 创建数据适配器用于填充数据集
            SqlDataAdapter sqlDataAdapter_1 = new SqlDataAdapter(ConStr, conn);

            // 设置数据适配器的查询命令
            sqlDataAdapter_1.SelectCommand = cmd;

            // 创建数据集对象
            DataSet dataSet_1 = new DataSet();

            // 使用数据适配器填充数据集
            sqlDataAdapter_1.Fill(dataSet_1, tb);

            // 获取数据表的列数
            int Column = dataSet_1.Tables[0].Columns.Count;

            // 创建返回数组，大小等于列数
            string[] Array1 = new string[Column];

            // 遍历所有列，读取指定行每列的数据
            for (int i = 0; i < Column; i++)
            {
                // 将指定行第i列的数据转换为字符串并存储到返回数组中
                Array1[i] = dataSet_1.Tables[0].Rows[idex][i].ToString();
            }

            // 关闭数据库连接，释放资源
            conn.Close();

            // 返回包含指定行所有列数据的数组
            return Array1;
        }

        /// <summary>
        /// 更新数据库数据 - 报警区间和条码配置
        /// 更新3B、3D、3W型号的上限报警区间和固定条码配置
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">包含6个配置值的字符串数组：
        /// [0]上限报警区间3B, [1]上限报警区间3D, [2]上限报警区间3W,
        /// [3]固定条码3B, [4]固定条码3D, [5]固定条码3W</param>
        public void UpdataDtata1(string db, string tb, string[] Str1)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建UPDATE SQL语句：更新6个配置字段
            string content1 = " USE " + db + " UPDATE  " + tb + " set  上限报警区间3B =" + Str1[0] +
                             ", 上限报警区间3D = " + Str1[1] +
                             ", 上限报警区间3W = " + Str1[2] +
                             ", 固定条码3B = '" + Str1[3] +
                             "', 固定条码3D = '" + Str1[4] +
                             "', 固定条码3W = '" + Str1[5] + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新数据库数据 - 动态参数配置
        /// 根据参数数量动态构建更新语句，更新多个参数值
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">包含参数值的字符串数组</param>
        /// <param name="Num">参数数量</param>
        public void UpdataDtata3(string db, string tb, string[] Str1, int Num)
        {
            // 初始化更新字段字符串
            string Str = "";

            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 动态构建SET部分的更新字段字符串
            for (int i = 0; i < Num; i++)
            {
                // 构建"参数i = '值i',"格式的字符串
                Str = Str + "参数" + i + " = '" + Str1[i] + "',";
            }

            // 去除末尾多余的逗号
            Str = Str.TrimEnd(',');

            // 构建完整的UPDATE SQL语句，使用参数0作为WHERE条件
            string content1 = " USE " + db + " UPDATE  " + tb + " set " + Str + " WHERE  参数0= '" + Str1[0] + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新数据库数据 - 固定13参数配置
        /// 更新包含13个参数的配置表，使用参数0作为条件
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">包含13个参数值的字符串数组</param>
        public void UpdataDtata31(string db, string tb, string[] Str1)
        {
            // 使用try-catch确保更新操作的异常处理
            try
            {
                // 创建数据库连接对象
                SqlConnection conn = new SqlConnection(ConStr);

                // 检查连接状态，如果未打开则同步打开连接
                if (conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }

                // 构建UPDATE SQL语句：更新参数1到参数12，使用参数0作为WHERE条件
                string content1 = " USE " + db + " UPDATE  " + tb + " set " +
                                " 参数1 = '" + Str1[1] +
                                "', 参数2 = '" + Str1[2] +
                                "', 参数3 = '" + Str1[3] +
                                "', 参数4 = '" + Str1[4] +
                                "', 参数5 = '" + Str1[5] +
                                "', 参数6 = '" + Str1[6] +
                                "', 参数7 = '" + Str1[7] +
                                "', 参数8 = '" + Str1[8] +
                                "', 参数9 = '" + Str1[9] +
                                "', 参数10 = '" + Str1[10] +
                                "', 参数11 = '" + Str1[11] +
                                "', 参数12 = '" + Str1[12] + " 'where 参数0='" + Str1[0] + "'";

                // 创建SQL命令对象
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 执行更新操作
                cmd.ExecuteNonQuery();

                // 关闭数据库连接，释放资源
                conn.Close();
            }
            catch (Exception ex)
            {
                // 静默处理异常，实际项目中建议记录日志
            }
        }

        /// <summary>
        /// 更新数据库数据 - 双参数配置
        /// 更新参数10和参数11两个字段的值
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">参数10的值</param>
        /// <param name="Str2">参数11的值</param>
        public void UpdataDtata4(string db, string tb, string Str1, string Str2)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建UPDATE SQL语句：更新参数10和参数11
            string content1 = " USE " + db + " UPDATE  " + tb + " set " +
                            " 参数10 ='" + Str1 +
                            "', 参数11 = '" + Str2 + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新数据库数据 - 三参数配置
        /// 更新参数12、参数13和参数22三个字段的值
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">参数12的值</param>
        /// <param name="Str2">参数13的值</param>
        /// <param name="Str3">参数22的值</param>
        public void UpdataDtata5(string db, string tb, string Str1, string Str2, string Str3)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建UPDATE SQL语句：更新参数12、参数13和参数22
            string content1 = " USE " + db + " UPDATE  " + tb + " set " +
                            " 参数12 ='" + Str1 +
                            "' ,参数13 ='" + Str2 +
                            "', 参数22 = '" + Str3 + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新数据库数据 - 10参数配置
        /// 更新参数0到参数9共10个字段的值
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str">包含10个参数值的字符串数组</param>
        public void UpdataDtata51(string db, string tb, string[] Str)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建UPDATE SQL语句：更新参数0到参数9
            string content1 = " USE " + db + " UPDATE  " + tb + " set " +
                            " 参数0 ='" + Str[0] +
                            "' ,参数1 ='" + Str[1] +
                            "' ,参数2 ='" + Str[2] +
                            "' ,参数3 ='" + Str[3] +
                            "' ,参数4 ='" + Str[4] +
                            "' ,参数5 ='" + Str[5] +
                            "' ,参数6 ='" + Str[6] +
                            "' ,参数7 ='" + Str[7] +
                            "' ,参数8 ='" + Str[8] +
                            "', 参数9 = '" + Str[9] + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新数据库数据 - 产品参数配置
        /// 更新产品相关的8个参数配置字段
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="Str1">包含8个参数值的字符串数组：
        /// [0]产品, [1]触发指令, [2]PIN1针偏差区间, [3]PIN2针偏差区间,
        /// [4]PIN3针偏差区间, [5]PIN针倾斜角度, [6]PIN针间隔区间Low, [7]PIN针间隔区间High</param>
        /// <param name="Str2">产品名称，用于WHERE条件</param>
        public void UpdataDtata4(string db, string tb, string[] Str1, string Str2)
        {
            // 创建数据库连接对象
            SqlConnection conn = new SqlConnection(ConStr);

            // 检查连接状态，如果未打开则同步打开连接
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            // 构建UPDATE SQL语句：更新8个产品参数字段，使用产品名称作为WHERE条件
            string content1 = " USE " + db + " UPDATE  " + tb +
                             " set  产品 ='" + Str1[0] +
                             "', 触发指令 = '" + Str1[1] +
                             "', PIN1针偏差区间 = '" + Str1[2] +
                             "', PIN2针偏差区间 = '" + Str1[3] +
                             "', PIN3针偏差区间 = '" + Str1[4] +
                             "', PIN针倾斜角度 = '" + Str1[5] +
                             "', PIN针间隔区间Low = '" + Str1[6] +
                             "', PIN针间隔区间High = '" + Str1[7] +
                             "'" + " where 产品= '" + Str2 + "'";

            // 创建SQL命令对象
            SqlCommand cmd = new SqlCommand(content1, conn);

            // 执行更新操作
            cmd.ExecuteNonQuery();

            // 关闭数据库连接，释放资源
            conn.Close();
        }

        /// <summary>
        /// 更新运行时间计时数据
        /// 用于设备断电保持功能，更新运行时间记录
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="CountD">运行时间值（浮点数）</param>
        public void UpdataRetainData(string db, string tb, float CountD)
        {
            // 使用try-catch确保更新操作的异常处理
            try
            {
                // 创建数据库连接对象
                SqlConnection conn = new SqlConnection(ConStr);

                // 检查连接状态，如果未打开则异步打开连接
                if (conn.State != ConnectionState.Open)
                {
                    conn.OpenAsync();
                }

                // 构建UPDATE SQL语句：更新运行时间字段
                string content1 = " USE " + db + " UPDATE  " + tb + " set  运行时间 =" + CountD;

                // 创建SQL命令对象
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 执行更新操作
                cmd.ExecuteNonQuery();

                // 注释掉的委托调用，可用于通知更新成功
                // listB_A("数据库表创建成功");//调用这个委托
            }
            catch (Exception)
            {
                // 注释掉的委托调用，可用于通知更新失败
                // listB_A("数据库表已存在，创建失败");//调用这个委托
            }
        }


        /// <summary>
        /// 手动更新TCP/IP通信参数配置
        /// 用于修改网络通信相关的配置参数
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="P1">TCP/IP地址</param>
        /// <param name="P2">端口号</param>
        /// <param name="P3">参数1值</param>
        /// <param name="P4">参数2值</param>
        /// <param name="P5">参数3值</param>
        /// <param name="P6">参数4值</param>
        public void UpdataParameter1(string db, string tb, string P1, string P2, string P3, string P4, string P5, string P6)
        {
            try
            {
                // 创建新的数据库连接
                SqlConnection conn = new SqlConnection(ConStr);

                // 确保连接处于打开状态
                if (conn.State != ConnectionState.Open)
                {
                    conn.OpenAsync();  // 异步打开连接
                }

                // 构建各个字段的更新字符串
                string A1 = "TCPIP=" + "'" + P1 + "'" + ",";    // TCP/IP地址字段
                string A2 = "端口号=" + "'" + P2 + "'" + ",";    // 端口号字段
                string A3 = "参数1=" + "'" + P3 + "'" + ",";     // 通用参数1字段
                string A4 = "参数2=" + "'" + P4 + "'" + ",";     // 通用参数2字段
                string A5 = "参数3=" + "'" + P5 + "'" + ",";     // 通用参数3字段
                string A6 = "参数4=" + "'" + P6 + "'";           // 通用参数4字段

                // 合并所有更新字段
                string A7 = A1 + A2 + A3 + A4 + A5 + A6;

                // 构建完整的UPDATE语句
                string content1 = " USE " + db + " UPDATE  " + tb + " set  " + A7;

                // 创建SQL命令对象
                SqlCommand cmd = new SqlCommand(content1, conn);

                // 执行更新操作
                cmd.ExecuteNonQuery();

                // 关闭数据库连接
                conn.Close();
            }
            catch (Exception)
            {
                // 更新失败，静默处理异常
                // 实际项目中建议记录错误日志
            }
        }

        /// <summary>
        /// 插入主测试数据表记录
        /// 用于记录特征检测的详细结果数据
        /// </summary>
        /// <param name="Str1">特征名称</param>
        /// <param name="R1">理论尺寸值</param>
        /// <param name="R2">公差上限值</param>
        /// <param name="R3">公差下限值</param>
        /// <param name="R4">实际测量尺寸值</param>
        /// <param name="R5">偏差值</param>
        /// <param name="Str2">判定结果（OK/NG）</param>
        public void UpDate_MainTable(string Str1, float R1, float R2, float R3, float R4, float R5, string Str2)
        {
            // 创建新的数据库连接
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 构建插入语句，包含特征检测的所有相关字段
            string str_1 = " USE  TestBoxPro  insert into MainTable (特征名称,理论尺寸,公差上限,公差下限,实际尺寸 , 偏差, 判定) VALUES (' " + Str1 + "','" + R1 + "','" + R2 + "','" + R3 + "','" + R4 + "','" + R5 + "','" + Str2 + "')";

            try
            {
                // 确保连接处于打开状态
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.OpenAsync();  // 异步打开连接

                    // 创建SQL命令并执行插入操作
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行数据插入
                }
            }
            catch (Exception)
            {
                // 插入失败，静默处理异常
                // 实际项目中建议记录错误日志
            }
        }

        /// <summary>
        /// 删除参数设置表中的配方记录
        /// 根据配方名称删除对应的参数配置记录
        /// </summary>
        /// <param name="str0">要删除的配方名称</param>
        public void DeleteData1(string str0)
        {
            // 创建新的数据库连接
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 构建删除语句，根据配方名称删除记录
            string str_1 = " USE  QmlData  DELETE FROM ParameterSetTable where  配方=" + str0;

            try
            {
                // 确保连接处于打开状态
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();  // 同步打开连接

                    // 创建SQL命令并执行删除操作
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行删除操作
                }
            }
            catch (Exception)
            {
                // 删除失败，静默处理异常
                // 实际项目中建议记录错误日志
            }

            // 确保连接被关闭
            connection_1.Close();
        }

        /// <summary>
        /// 通用删除数据方法
        /// 根据参数0的值删除指定表中的记录
        /// </summary>
        /// <param name="db">数据库名称</param>
        /// <param name="tb">数据表名称</param>
        /// <param name="str0">参数0的值（作为删除条件）</param>
        public void DeleteData2(string db, string tb, string str0)
        {
            // 创建新的数据库连接
            SqlConnection connection_1 = new SqlConnection(ConStr);

            // 构建删除语句，根据参数0的值删除记录
            string str_1 = " USE " + db + " DELETE FROM  " + tb + "  where  参数0= '" + str0 + "'";

            try
            {
                // 确保连接处于打开状态
                if (connection_1.State != ConnectionState.Open)
                {
                    connection_1.Open();  // 同步打开连接

                    // 创建SQL命令并执行删除操作
                    SqlCommand sqlCommand_1 = new SqlCommand(str_1, connection_1);
                    sqlCommand_1.ExecuteNonQuery();  // 执行删除操作
                }
            }
            catch (Exception)
            {
                // 删除失败，静默处理异常
                // 实际项目中建议记录错误日志
            }

            // 确保连接被关闭
            connection_1.Close();
        }
    }
}